#!/usr/bin/env python
# -*- coding: utf-8 -*-

import gtk
from commande import Commande
from gtkmvc import View

class MyView (View):

	glade = "example.glade"
	top = "window1"
	
	def __init__(self, ctrl):
		View.__init__(self, ctrl, self.glade)    
		
		#Buffer du textView
		buffer = self['txtExcude'].get_buffer()
		self.not_editable_tag = buffer.create_tag(
			paragraph_background="grey", editable=False)		
		buffer.apply_tag(
			self.not_editable_tag, 
			buffer.get_start_iter(), 
			buffer.get_end_iter())
		return

	def vider_saisies(self):
		self['chkExclude'].set_active(False)
		self['txtSource'].set_text("")
		self['txtDestination'].set_text("")
		self['txtUser'].set_text("")
		self['txtHote'].set_text("")
		buffer = self['txtExcude'].get_buffer()
		buffer.set_text("")
	
	def getSaisies(self):
		"""Retourne le liste des saisies utilisateur"""
		return (self['txtSource'].get_text(),
			self['txtDestination'].get_text(),
			self['txtHote'].get_text(),
			self['txtUser'].get_text(),
			self['txtPassword'].get_text())

	def fillCombo(self, listItem):
		"""Ajoute la liste listItem a la combobox"""
		for elt in listItem:
			self['cbBackup'].append_text(elt)

	def getActive(self):
		"""Retourne la chaine de l'element selectionne dans la combo"""
		combobox = self['cbBackup']
		model = combobox.get_model()
		active = combobox.get_active()
		if active < 0:
			return None
		return model[active][0]

	def displayAttributes(self, commande):
		"""Affiche la liste des attributs 
		dans les zones de saisie successives """
		print commande.exclusions
		self['txtSource'].set_text(commande.source)
		self['txtDestination'].set_text(commande.destination)
		self['txtUser'].set_text(commande.user)
		self['txtHote'].set_text(commande.host)
		if len(commande.exclusions) > 0:
			self['chkExclude'].set_active(True)
			for exclusion in commande.exclusions:
				buffer = self['txtExcude'].get_buffer()
				end = buffer.get_end_iter() 
				buffer.insert(end,exclusion)
				buffer.insert(end,"\n")

	def set_mode_editable(self, isEditable):
		print isEditable
		buffer = self['txtExcude'].get_buffer()
		start, end = buffer.get_bounds()
		buffer.remove_tag(self.not_editable_tag, start, end)
		if not isEditable:
			buffer.apply_tag(self.not_editable_tag, start, end)

	def alert(self, message):
		from msgBox.msgBox import messageBox
		self.msg = messageBox(message)

	pass # end of class

from ConfigParser import ConfigParser, NoSectionError, NoOptionError
from gtkmvc import Model
import os
import sys
class MyModel(Model):

	def __init__(self):
		Model.__init__(self)        

		# load config object
		# run package default configuration and overload with user settings
		self.config = ConfigParser()
		self.config.read([
			os.path.join(sys.path[0], 'example.ini'),
			os.path.expanduser(os.path.join('~', '.example.ini')),])
		return

	def execute(self, commande, password):
		"""	
		Execute la commande rsync avec les données saisies dans l'interface
		"""
		print commande
		import pexpect
		p = pexpect.spawn(commande)
		
		#envoie du mot de passe	
		try:
			p.expect ('password:')
			print 'Envoie du pw'
			p.sendline(password)
			#p.interact()#sans ca ca marche pas ????
			# close ne marche pas pour raisoudre le probleme
			#peut etre car c'est rsync qui est une commande en plus de ssh ???
			#p.close()
			return p.read()
			#return True
		except pexpect.EOF:
			print 'erreur dans la commande '
			print commande
			return None
		except pexpect.TIMEOUT:
			print 'timeout'
			return None

	def get_sections(self):
		"""
		Retourne la liste des sauvegardes
		Configurees dans le fichier ini
		=> liste des sections		
		"""
		try:
			return self.config.sections()
		except:
			return []

	def get_exclusions(self, section):
		"""
		Retourne la liste des exclusions ou une liste vide:
		- Recherche le nom du fichier d'exclusion 
		=> option  exclude_file
		dans le fichier de config
		- charge le fichier et retourne chaque ligne sous la forme 
		d'une liste
    """
		from util.util import Fichier_de_config
		if self.config.has_option(section, 'exclude_file'):
			try:
				#chargement du fichier d'exclusion
				file = self.config.get(section,'exclude_file')
				f = Fichier_de_config(file)
				return f.parse2TrueLine()
			except:
				print "Erreur du chargement du fihier d'exclusion"
		return []

	def getBackupAttributes(self, section):
		""" 
			Retourne une commande
			En cas d'erreur retourne None
		"""
		try:
			commande = Commande()
			commande.source = self.config.get(section, 'source')
			commande.destination= self.config.get(section, 'destination') 
			commande.user = self.config.get(section, 'utilisateur')
			commande.host = self.config.get(section, 'hote')
			commande.exclusions = self.get_exclusions(section)
			return commande	
		except NoSectionError:
			print 'Pas de section ' + section
		except NoOptionError:
			print "Une option n'existe pas"
		except IOError:
			print "Erreur de chargement du fichier d'exclusion"
		return None

	pass # end of class


from gtkmvc import Controller
class MyController(Controller):

	def __init__(self, model):
		print 'init controller'
		Controller.__init__(self, model)
		return

	def register_view(self, view):
		Controller.register_view(self, view)

		# sets initial values for the view
		self.view.fillCombo(self.model.get_sections())


	# signals handling
	def on_chkExclude_toggled(self, button):
		print 'toggle de la check box'
		self.view.set_mode_editable(button.get_active())

	def on_ok_clicked(self, button):
		#TODO Controle source, destination, hote
		source,destination,hote,user, pw = self.view.getSaisies()
		cde = 'rsync -av ' + source + ' ' + user + \
				'@' + hote + ':' + destination
		retour = self.model.execute(cde, pw)		
		if retour != None:
			print 'ok'
			self.view.alert("Sauvegarde effectuée avec succès\n" + retour)
		else:
			print 'echec de la commande'
			self.view.alert("Echec de la commande \n " + cde)
		
		#gtk.main_quit()
		return True

	def on_quit_clicked(self,button):
		gtk.main_quit()
		return True

	def on_window1_delete(self, w, e):
		gtk.main_quit()
		return True

	def on_cbBackup_changed(self, attribute):
		self.view.vider_saisies()
		backup_selectionne = self.view.getActive()
		commande = self.model.getBackupAttributes(backup_selectionne)
		if commande is None:
			self.view.alert("Sauvegarde: " + backup_selectionne + "\nProblème de chargement des propriétés")
		else:
			self.view.displayAttributes(commande)

	pass # end of class



m = MyModel()
c = MyController(m)
v = MyView(c)

gtk.main()
